qint8   = int8(19);
qint16  = int16(19);
qint32  = int32(19);
qint64  = int64(19);
quint8  = int8(19);
quint16 = int16(19);
quint32 = int32(19);
quint64 = int64(19);

qbool   = logical(1);

qchar   = 'a';

qfloat32 = single(1.4);
qfloat64 = double(1.4);

complexqint8   = complex(int8(19));
complexqint16  = complex(int16(19));
complexqint32  = complex(int32(19));
complexqint64  = complex(int64(19));
complexquint8  = complex(int8(19));
complexquint16 = complex(int16(19));
complexquint32 = complex(int32(19));
complexquint64 = complex(int64(19));

complexqfloat32 = complex(single(1.4));
complexqfloat64 = complex(double(1.4));

% Iskomentarisane konverzije su nedopustene !!!

%
% Dopustene konverzije u LOGICAL tip
%
logical(qint8);
logical(qint16);
logical(qint32);
logical(qint64);
logical(quint8);
logical(quint16);
logical(quint32);
logical(quint64);

logical(qbool);

% logical(char);

logical(qfloat32);
logical(qfloat64);

% logical(complexqint8);
% logical(complexqint16);
% logical(complexqint32);
% logical(complexqint64);
% logical(complexquint8);
% logical(complexquint16);
% logical(complexquint32);
% logical(complexquint64);

%
% Dopustene konverzije u CHAR tip
%
char(qint8);
char(qint16);
char(qint32);
char(qint64);
char(quint8);
char(quint16);
char(quint32);
char(quint64);

% char(qbool);

char(char);

char(qfloat32);
char(qfloat64);

% char(complexqint8);
% char(complexqint16);
% char(complexqint32);
% char(complexqint64);
% char(complexquint8);
% char(complexquint16);
% char(complexquint32);
% char(complexquint64);

%
% Dopustene konverzije u INT8 tip
%
int8(qint8);
int8(qint16);
int8(qint32);
int8(qint64);
int8(quint8);
int8(quint16);
int8(quint32);
int8(quint64);

int8(qbool);

int8(char);

int8(qfloat32);
int8(qfloat64);

int8(complexqint8);
int8(complexqint16);
int8(complexqint32);
int8(complexqint64);
int8(complexquint8);
int8(complexquint16);
int8(complexquint32);
int8(complexquint64);

%
% Dopustene konverzije u INT16 tip
%
int16(qint8);
int16(qint16);
int16(qint32);
int16(qint64);
int16(quint8);
int16(quint16);
int16(quint32);
int16(quint64);

int16(qbool);

int16(char);

int16(qfloat32);
int16(qfloat64);

int16(complexqint8);
int16(complexqint16);
int16(complexqint32);
int16(complexqint64);
int16(complexquint8);
int16(complexquint16);
int16(complexquint32);
int16(complexquint64);

%
% Dopustene konverzije u INT32 tip
%
int32(qint8);
int32(qint16);
int32(qint32);
int32(qint64);
int32(quint8);
int32(quint16);
int32(quint32);
int32(quint64);

int32(qbool);

int32(char);

int32(qfloat32);
int32(qfloat64);

int32(complexqint8);
int32(complexqint16);
int32(complexqint32);
int32(complexqint64);
int32(complexquint8);
int32(complexquint16);
int32(complexquint32);
int32(complexquint64);

%
% Dopustene konverzije u INT64 tip
%
int64(qint8);
int64(qint16);
int64(qint32);
int64(qint64);
int64(quint8);
int64(quint16);
int64(quint32);
int64(quint64);

int64(qbool);

int64(char);

int64(qfloat32);
int64(qfloat64);

int64(complexqint8);
int64(complexqint16);
int64(complexqint32);
int64(complexqint64);
int64(complexquint8);
int64(complexquint16);
int64(complexquint32);
int64(complexquint64);

%
% Dopustene konverzije u UINT8 tip
%
uint8(qint8);
uint8(qint16);
uint8(qint32);
uint8(qint64);
uint8(quint8);
uint8(quint16);
uint8(quint32);
uint8(quint64);

uint8(qbool);

uint8(char);

uint8(qfloat32);
uint8(qfloat64);

uint8(complexqint8);
uint8(complexqint16);
uint8(complexqint32);
uint8(complexqint64);
uint8(complexquint8);
uint8(complexquint16);
uint8(complexquint32);
uint8(complexquint64);

%
% Dopustene konverzije u UINT16 tip
%
uint16(qint8);
uint16(qint16);
uint16(qint32);
uint16(qint64);
uint16(quint8);
uint16(quint16);
uint16(quint32);
uint16(quint64);

uint16(qbool);

uint16(char);

uint16(qfloat32);
uint16(qfloat64);

uint16(complexqint8);
uint16(complexqint16);
uint16(complexqint32);
uint16(complexqint64);
uint16(complexquint8);
uint16(complexquint16);
uint16(complexquint32);
uint16(complexquint64);

%
% Dopustene konverzije u UINT32 tip
%
uint32(qint8);
uint32(qint16);
uint32(qint32);
uint32(qint64);
uint32(quint8);
uint32(quint16);
uint32(quint32);
uint32(quint64);

uint32(qbool);

uint32(char);

uint32(qfloat32);
uint32(qfloat64);

uint32(complexqint8);
uint32(complexqint16);
uint32(complexqint32);
uint32(complexqint64);
uint32(complexquint8);
uint32(complexquint16);
uint32(complexquint32);
uint32(complexquint64);

%
% Dopustene konverzije u UINT64 tip
%
uint64(qint8);
uint64(qint16);
uint64(qint32);
uint64(qint64);
uint64(quint8);
uint64(quint16);
uint64(quint32);
uint64(quint64);

uint64(qbool);

uint64(char);

uint64(qfloat32);
uint64(qfloat64);

uint64(complexqint8);
uint64(complexqint16);
uint64(complexqint32);
uint64(complexqint64);
uint64(complexquint8);
uint64(complexquint16);
uint64(complexquint32);
uint64(complexquint64);

%
% Dopustene konverzije u FLOAT32 aka SINGLE tip
%
single(qint8);
single(qint16);
single(qint32);
single(qint64);
single(quint8);
single(quint16);
single(quint32);
single(quint64);

single(qbool);

single(char);

single(qfloat32);
single(qfloat64);

single(complexqint8);
single(complexqint16);
single(complexqint32);
single(complexqint64);
single(complexquint8);
single(complexquint16);
single(complexquint32);
single(complexquint64);

%
% Dopustene konverzije u FLOAT64 aka DOUBLE tip
%
double(qint8);
double(qint16);
double(qint32);
double(qint64);
double(quint8);
double(quint16);
double(quint32);
double(quint64);

double(qbool);

double(char);

double(qfloat32);
double(qfloat64);

double(complexqint8);
double(complexqint16);
double(complexqint32);
double(complexqint64);
double(complexquint8);
double(complexquint16);
double(complexquint32);
double(complexquint64);

%
% Koji sve tipovi imaju COMPLEX varijantu
%
complex(qint8);
complex(qint16);
complex(qint32);
complex(qint64);
complex(quint8);
complex(quint16);
complex(quint32);
complex(quint64);

% complex(qbool);

% complex(char);

complex(qfloat32);
complex(qfloat64);